#!/usr/bin/env python
# -*- coding: UTF-8 -*-

import SocketServer
import threading
import time

class ChatServerManager():
    
    SERVEUR_DESCRIPTION = "Serveur de Chat par telnet 0.1"
    
    #Dictionnaire des threads cliente
    __thread_dict = {}
    
    def __init__(self, port, host):
        #Initialise le serveur         
        print self.SERVEUR_DESCRIPTION
        print 'Démarage du serveur sur ', host, ':', str(port), '\r\n'
        #Démarage du serveur
        self.server = SocketServer.ThreadingTCPServer((str(host), int(port)), 
                                                      ChatServeurHandler)
        
    def kill_server(self):
        '''
        Ferme et arrete le serveur
        TODO: a tester         
        '''
        self.server.server_close()
        self.server.stopped = True
       
    def add_client(self, cli_thread):
        #Chargement de la connexion cliente
        self.__thread_dict[cli_thread.id] = {
                                             'HOST' : cli_thread.host,
                                             'NICK' : 'Moi',
                                             'UPSINCE' : 2009,
                                             'HANDLER' : cli_thread
                                             }
        #Construction du message de bienvenue        
        wellcome_mgs = self.format_msg((
                                         '-' * 50, 
                                         self.SERVEUR_DESCRIPTION,
                                         '',
                                         'Bienvenue !',
                                         '',
                                         'Host     : ' + cli_thread.host,
                                         'Nb. User : ' + str(5),
                                         '-' * 50
                                         ))
        #envois du message de connexion au client
        cli_thread.send_message(wellcome_mgs)
        
    def format_msg(self, msg_item):
        #Formate un message de sortie 
        formated_message = ''
        for i in msg_item:
            formated_message += "%s \r\n" % (i)  
        return formated_message
    
    def del_client(self, id_thread):
        self.send_message(self, id_thread)
        del self.__thread_dict[id_thread]
    
    def send_message(self, mfrom, line, to):
        #Si id de clienbt précisé
        if to > 0:
            self.__thread_dict[to].send_message(line)
        else:
            for i in self.__thread_dict:
                if i != mfrom:
                    message_line = '[%s] %s' % (self.__thread_dict[i]['NICK'], line)
                    self.__thread_dict[i]['HANDLER'].send_message(message_line)
    

class ChatServeurHandler(SocketServer.BaseRequestHandler):
    
    #ligne courante du client
    client_line = ""
    
    def setup(self):
        #affichage console de la connexion
        print self.client_address, 'Connexion cliente !'
        self.host = str(self.client_address[0])
        self.id = int(self.client_address[1]) #peut etre le port ?
        myChatServ.add_client(self)
        
    def handle(self):
        while 1:
            #récupération de l'entré cliente
            data = self.request.recv(1024)
            #Si l'entré courante est un retour chariot
            if data == '\r\n':
                if self.client_line[:1] == "/":
                    cmd_return = self.exec_commande(self.client_line[1:])
                    if cmd_return == "TERM_CONNEXION":
                        self.finish()
                        return
                    else:
                        #envois du résultat au client
                        self.request.send(cmd_return + "\r\n") 
                else:
                    #envois d'un message
                    myChatServ.send_message(self.id, self.client_line, 0)
                    print str(self.id) + ' > ' + self.client_line
                    #self.send_message(self.client_line)
            
                #vide la ligne cliente apres validation
                self.client_line = "" 
            else:
                #stockage dans la ligne courante
                self.client_line += data
                
    def send_message(self, msg_string):
        #Pour chaque trhead enregistrées comme actives
        self.request.send('\r\n' + msg_string + '\r\n')
            
    def exec_commande(self, cmd_string):
        print self.id + ' commande > ' + cmd_string
        if (cmd_string == "quit"):
            return "TERM_CONNEXION"
        if (cmd_string == "me"):
            return "Votre ID: " + self.id
        #si aucune commande match
        return "Erreur : commande inconnue"

    def finish(self):
        #Déconnexion du client
        print self.id, 'est maintenan deconnecte'
        #suppression de la thread cliente comme thread active
        myChatServ.del_client(self.id)
       
        
    

if __name__ == '__main__':
    
    #création et lancement du serveur
    myChatServ = ChatServerManager(2009, 'localhost')
    myChatServ.server.serve_forever()

    

 